#ifndef __M_UTIL_H__
#define __M_UTIL_H__
#include "logger.hpp"
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <memory>
#include <vector>
#include <cstdint>
#include <jsoncpp/json/json.h>
#include <mysql/mysql.h>

#include <websocketpp/server.hpp>
#include <websocketpp/config/asio_no_tls.hpp>

typedef websocketpp::server<websocketpp::config::asio> wsserver_t;
//mysql工具类
class mysql_util
{
    public:
        static MYSQL *mysql_create(const std::string &host,
        const std:: string &username,
        const std:: string &password,
        const std:: string &dbname,
        uint16_t port=3306)
        {
            //1.初始化mysql句柄
            MYSQL *mysql=mysql_init(nullptr);
            if(!mysql)
            {
                ELOG("初始化mysql句柄失败");
                return nullptr;
            }
            //2.连接服务器
            //MYSQL *mysql_real_connect(MYSQL *mysql, const char *host, const char *user,  const char *passwd,const char *db, unsigned int port,  const char *unix_socket, unsigned long client_flag);
            if(mysql_real_connect(mysql,host.c_str(),username.c_str(),password.c_str(),dbname.c_str(),port,nullptr,0)==nullptr)
            {
                ELOG("连接数据库失败");
                ELOG("错误信息:%s",mysql_error(mysql));
                mysql_close(mysql);
                return nullptr;
            }
            //3.设置客户端字符集
            //int mysql_set_character_set(MYSQL *mysql, const char *csname)
            if(mysql_set_character_set(mysql,"utf8")!=0)
            {
                ELOG("设置字符集失败");
                ELOG("错误信息:%s",mysql_error(mysql));
                mysql_close(mysql);
                return nullptr;
            }
            //4.选择要操作的数据库
            //int mysql_select_db(MYSQL *mysql, const char *db)
            if(mysql_select_db(mysql,dbname.c_str())!=0)
            {
                ELOG("选择数据库失败");
                ELOG("错误信息:%s",mysql_error(mysql));
                mysql_close(mysql);
                return nullptr;
            }
            return mysql;
        }
        //5.执行sql语句
        static bool mysql_exec(MYSQL *mysql,const std::string &sql)
        {
            //int mysql_query(MYSQL *mysql, const char *q)
            if(mysql_query(mysql,sql.c_str())!=0)
            {
                ELOG("执行sql语句失败");
                ELOG("错误信息:%s",mysql_error(mysql));
                return false;
            }
            return true;
        }
        //6.关闭mysql连接
        static void mysql_destroy(MYSQL *mysql)
        {
            if(mysql!=nullptr)
            {
                mysql_close(mysql);
            }
            return;
        }
};
// Json操作工具类
class json_util
{
    public:
    //Json序列化
    static bool serialize(const Json::Value &root,std::string &str)
    {
        //2.实例化一个StreamWriterBuilder对象
        Json::StreamWriterBuilder swb;
        swb["emitUTF8"] = true;//设置输出为utf-8编码
        //3.使用StreamWriterBuilder对象创建一个StreamWriter对象
        std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
        //4.使用StreamWriter对象将json::value对象序列化为字符串
        std::stringstream ss;
        int ret=sw->write(root,&ss);
        if(ret!=0)
        {
            ELOG("Json序列化失败");
            return false;
        }
        str=ss.str();
        return true;
    }
    //Json反序列化
    static bool deserialize(const std::string &str,Json::Value &root)
    {
        //1.实例化一个CharReaderBuilder工厂类对象
        Json::CharReaderBuilder crb;
        //2.使用CharReaderBuilder对象创建一个CharReader对象
        std::unique_ptr<Json::CharReader> cr(crb.newCharReader());
        //3.已有Json::Value对象root存储解析后的数据
        //4.定义一个字符串对象存储错误信息
        std::string err;
        //4.使用charReader对象进行Josn格式字符串的反序列化
        bool ret=cr->parse(str.c_str(),str.c_str()+str.size(),&root,&err);
        if(ret==false)
        {
            ELOG("Json反序列化失败:%s",err.c_str());
            return false;
        }
        return true;
    }
};
// 字符串操作工具类
class string_util
{
    public:
        static int split(const std::string &str,const std::string &sep,std::vector<std::string> &res)
        {
            size_t pos,idx=0;
            while(idx<str.size())
            {
                {
                    pos=str.find(sep,idx);
                    if(pos==std::string::npos)
                    {
                        res.push_back(str.substr(idx));
                        break;
                    }
                    if(pos==idx)
                    {
                        idx=pos+sep.size();
                        continue;
                    }
                    res.push_back(str.substr(idx,pos-idx));
                    idx=pos+sep.size();
                }
            }
            return res.size();
        }
};
// 文件操作工具类
class file_util {
   public:
        static bool read(const std::string &filename, std::string &body) 
        {
            //打开文件
            std::ifstream ifs(filename, std::ios::binary);
            if (ifs.is_open() == false) 
            {
                ELOG("%s file open failed!!", filename.c_str());
                return false;
            }
            //获取文件大小
            size_t fsize = 0;
            ifs.seekg(0, std::ios::end);
            fsize = ifs.tellg();
            ifs.seekg(0, std::ios::beg);
            body.resize(fsize);
            //将文件所有数据读取出来
            ifs.read(&body[0], fsize);
            if (ifs.good() == false) 
            {
                ELOG("read %s file content failed!", filename.c_str());
                ifs.close();
                return false;
            }
            //关闭文件
            ifs.close();
            return true;
        }
};

#endif